﻿package mortal.game.utils
{
    import Message.Client.*;
    import Message.DB.Tables.*;
    import Message.Public.*;
    import __AS3__.vec.*;
    import com.gengine.utils.*;
    import extend.language.*;
    import flash.utils.*;
    import mortal.component.gconst.*;
    import mortal.game.cache.*;
    import mortal.game.manager.*;
    import mortal.game.manager.msgTip.*;
    import mortal.game.resource.*;
    import mortal.game.resource.info.item.*;
    import mortal.game.resource.tableConfig.*;
    import mortal.game.view.common.util.*;
    import mortal.game.view.mount.data.*;
    import mortal.game.view.palyer.data.*;
    import mortal.game.view.palyer.util.*;
    import mortal.game.view.skill.*;

    public class MountUtil extends Object
    {
        public static var maxMountLevel:int = 10;
        private static var _mountGroupItem:ItemData = new ItemData(410390001);
        private static var _mountQualifiedItem:ItemData = new ItemData(410350001);

        public function MountUtil()
        {
            return;
        }// end function

        public static function get mountCombat() : int
        {
            var _loc_8:String = null;
            var _loc_9:Array = null;
            var _loc_10:Dictionary = null;
            var _loc_11:SkillInfo = null;
            var _loc_12:SkillInfo = null;
            var _loc_13:int = 0;
            var _loc_14:Number = NaN;
            var _loc_15:ItemData = null;
            var _loc_1:* = MountConfig.instance.attribute;
            var _loc_2:* = Cache.instance.mount.mountData;
            var _loc_3:* = PlayerTargetConfig.instance.getInfoById(_mountGroupItem.itemInfo.effectEx);
            var _loc_4:* = Cache.instance.pack.mountPackCache.allItems;
            var _loc_5:Number = 0;
            var _loc_6:* = Cache.instance.vip.level;
            var _loc_7:* = VipConfig.instance.getVipConfigByType(EVipRecordType._EVipRecordTypeMountEffect);
            for each (_loc_8 in _loc_1)
            {
                
                _loc_14 = 0;
                _loc_14 = _loc_14 + _loc_2.tMountConfig[_loc_8];
                for each (_loc_15 in _loc_4)
                {
                    
                    if (_loc_15 && !ItemsUtil.isPrescriOutTime(_loc_15))
                    {
                        _loc_14 = _loc_14 + _loc_15.itemInfo[_loc_8];
                    }
                }
                if (_loc_2.sPublicMount.totalGrowthNum > 0 && _loc_3.hasOwnProperty(_loc_8))
                {
                    _loc_14 = _loc_14 + _loc_3[_loc_8] * _loc_2.sPublicMount.totalGrowthNum;
                }
                if (_loc_2.sPublicMount.totalTalentNum > 0)
                {
                    _loc_14 = _loc_14 + _loc_2.tMountConfig[_loc_8] * _mountQualifiedItem.itemInfo.effectEx * 0.01 * _loc_2.sPublicMount.totalTalentNum;
                }
                if (_loc_6 > 0)
                {
                    _loc_14 = _loc_14 + _loc_2.tMountConfig[_loc_8] * int(_loc_7.desc) * int(_loc_7["vip" + _loc_6]) * 0.01;
                }
                _loc_14 = CombatUtil.getCombatValueByName(_loc_8, int(_loc_14));
                _loc_5 = _loc_5 + _loc_14;
            }
            _loc_9 = SkillUtil.getLearnedSkillByType(ESkillCategory._EMountSkill);
            _loc_10 = new Dictionary();
            _loc_13 = 0;
            while (_loc_13 < _loc_9.length)
            {
                
                _loc_11 = _loc_9[_loc_13];
                _loc_12 = _loc_10[_loc_11.tSkill.posType] as SkillInfo;
                if (_loc_12 == null || _loc_12 && _loc_11.tSkill.skillLevel > _loc_12.tSkill.skillLevel)
                {
                    _loc_10[_loc_11.tSkill.posType] = _loc_11;
                }
                _loc_13++;
            }
            for each (_loc_11 in _loc_10)
            {
                
                _loc_5 = _loc_5 + _loc_11.tSkill.combat;
            }
            return int(_loc_5);
        }// end function

        public static function get nextMountAddCombat() : int
        {
            var _loc_8:String = null;
            var _loc_9:Number = NaN;
            var _loc_10:Number = NaN;
            var _loc_1:* = Cache.instance.mount.mountData;
            if (_loc_1.mountLevel >= maxMountLevel)
            {
                return 0;
            }
            var _loc_2:* = MountConfig.instance.attribute;
            var _loc_3:* = MountConfig.instance.getMountInfoByCode((_loc_1.mountLevel + 1));
            var _loc_4:Number = 0;
            var _loc_5:Number = 0;
            var _loc_6:* = Cache.instance.vip.level;
            var _loc_7:* = VipConfig.instance.getVipConfigByType(EVipRecordType._EVipRecordTypeMountEffect);
            for each (_loc_8 in _loc_2)
            {
                
                _loc_9 = 0;
                _loc_9 = _loc_9 + _loc_1.tMountConfig[_loc_8];
                if (_loc_1.sPublicMount.totalTalentNum > 0)
                {
                    _loc_9 = _loc_9 + _loc_1.tMountConfig[_loc_8] * _mountQualifiedItem.itemInfo.effectEx * 0.01 * _loc_1.sPublicMount.totalTalentNum;
                }
                if (_loc_6 > 0)
                {
                    _loc_9 = _loc_9 + _loc_1.tMountConfig[_loc_8] * int(_loc_7.desc) * int(_loc_7["vip" + _loc_6]) * 0.01;
                }
                _loc_9 = CombatUtil.getCombatValueByName(_loc_8, _loc_9);
                _loc_4 = _loc_4 + _loc_9;
                _loc_10 = 0;
                _loc_10 = _loc_10 + _loc_3[_loc_8];
                if (_loc_1.sPublicMount.totalTalentNum > 0)
                {
                    _loc_10 = _loc_10 + _loc_3[_loc_8] * _mountQualifiedItem.itemInfo.effectEx * 0.01 * _loc_1.sPublicMount.totalTalentNum;
                }
                if (_loc_6 > 0)
                {
                    _loc_10 = _loc_10 + _loc_3[_loc_8] * int(_loc_7.desc) * int(_loc_7["vip" + _loc_6]) * 0.01;
                }
                _loc_10 = CombatUtil.getCombatValueByName(_loc_8, _loc_10);
                _loc_5 = _loc_5 + _loc_10;
            }
            return int(_loc_5) - int(_loc_4);
        }// end function

        public static function mountAttrByName(param1:String) : int
        {
            var _loc_8:ItemData = null;
            var _loc_2:* = Cache.instance.mount.mountData;
            var _loc_3:* = PlayerTargetConfig.instance.getInfoById(_mountGroupItem.itemInfo.effectEx);
            var _loc_4:* = Cache.instance.pack.mountPackCache.allItems;
            var _loc_5:int = 0;
            _loc_5 = _loc_5 + _loc_2.tMountConfig[param1];
            var _loc_6:* = Cache.instance.vip.level;
            var _loc_7:* = VipConfig.instance.getVipConfigByType(EVipRecordType._EVipRecordTypeMountEffect);
            for each (_loc_8 in _loc_4)
            {
                
                if (_loc_8 && !ItemsUtil.isPrescriOutTime(_loc_8))
                {
                    _loc_5 = _loc_5 + _loc_8.itemInfo[param1];
                }
            }
            if (_loc_2.sPublicMount.totalGrowthNum > 0 && _loc_3.hasOwnProperty(param1))
            {
                _loc_5 = _loc_5 + _loc_3[param1] * _loc_2.sPublicMount.totalGrowthNum;
            }
            if (_loc_2.sPublicMount.totalTalentNum > 0)
            {
                _loc_5 = _loc_5 + _loc_2.tMountConfig[param1] * _mountQualifiedItem.itemInfo.effectEx * 0.01 * _loc_2.sPublicMount.totalTalentNum;
            }
            if (_loc_6 > 0)
            {
                _loc_5 = _loc_5 + _loc_2.tMountConfig[param1] * int(_loc_7.desc) * int(_loc_7["vip" + _loc_6]) * 0.01;
            }
            return int(_loc_5);
        }// end function

        public static function getMountEquipCombatByItemData(param1:ItemData) : int
        {
            var _loc_4:String = null;
            var _loc_2:* = MountConfig.instance.attribute;
            var _loc_3:Number = 0;
            for each (_loc_4 in _loc_2)
            {
                
                _loc_3 = _loc_3 + CombatUtil.getCombatValueByName(_loc_4, param1.itemInfo[_loc_4]);
            }
            return int(_loc_3);
        }// end function

        public static function isEnoughLevel(param1:ItemData) : Boolean
        {
            return Boolean(param1.itemInfo.level <= Cache.instance.mount.mountData.sPublicMount.code);
        }// end function

        public static function getMountNameByCode(param1:int) : String
        {
            var _loc_2:* = HTMLUtil.addColor(MountConfig.instance.getMountInfoByCode(param1).name, ColorConfig.instance.getItemColor(Math.ceil(param1 / 2)).color);
            return _loc_2;
        }// end function

        public static function get isCanAdvanced() : Boolean
        {
            var _loc_4:int = 0;
            var _loc_5:int = 0;
            var _loc_7:int = 0;
            var _loc_8:Array = null;
            var _loc_9:int = 0;
            var _loc_1:* = Cache.instance.mount.mountData;
            if (_loc_1.mountLevel == 10)
            {
                return false;
            }
            var _loc_2:* = MountUtil.isHasBlessItem(EAdvanceType._EAdvanceMountAdvanced);
            if (_loc_2)
            {
                return true;
            }
            var _loc_3:* = Cache.instance.pack.backPackCache.getItemsByGroupCategoryAndType(EGroup._EGroupStuff, EStuff._EStuffAdvance, EAdvanceType._EAdvanceMountAdvanced);
            if (_loc_1.tMountConfig.blessClear)
            {
                if (_loc_1.sPublicMount.bless)
                {
                    return true;
                }
                _loc_8 = _loc_1.tMountConfig.advance.split("&");
                _loc_9 = (_loc_8[(_loc_8.length - 1)] as String).split("#")[0];
                _loc_5 = (_loc_9 - _loc_1.sPublicMount.advanceNum) * _loc_1.tMountConfig.propNum;
            }
            else
            {
                _loc_5 = _loc_1.tMountConfig.propNum;
            }
            var _loc_6:* = _loc_3.length;
            while (_loc_7 < _loc_6)
            {
                
                if (ItemsUtil.isPrescriOutTime(_loc_3[_loc_7] as ItemData))
                {
                }
                else if (_loc_1.mountLevel >= (_loc_3[_loc_7] as ItemData).itemInfo.effect)
                {
                    _loc_4 = _loc_4 + (_loc_3[_loc_7] as ItemData).itemAmount;
                }
                _loc_7++;
            }
            return _loc_4 >= _loc_5;
        }// end function

        public static function get isRideUp() : Boolean
        {
            return Cache.instance.role.entityInfo.mountCode > 0;
        }// end function

        public static function getAttrValueByName(param1:String, param2:int, param3:int, param4:Array, param5:Array, param6:int, param7:int, param8:int, param9:int) : int
        {
            var _loc_13:ItemData = null;
            var _loc_14:SPlayerItem = null;
            var _loc_15:TVip = null;
            var _loc_10:* = MountConfig.instance.getMountInfoByCode(param2, param3);
            var _loc_11:* = PlayerTargetConfig.instance.getInfoById(_mountGroupItem.itemInfo.effectEx);
            var _loc_12:int = 0;
            _loc_12 = _loc_12 + _loc_10[param1];
            for each (_loc_14 in param5)
            {
                
                _loc_13 = new ItemData(_loc_14);
                if (_loc_13 && !ItemsUtil.isPrescriOutTime(_loc_13))
                {
                    _loc_12 = _loc_12 + _loc_13.itemInfo[param1];
                }
            }
            if (param6 > 0 && _loc_11.hasOwnProperty(param1))
            {
                _loc_12 = _loc_12 + _loc_11[param1] * param6;
            }
            if (param7 > 0)
            {
                _loc_12 = _loc_12 + _loc_10[param1] * _mountQualifiedItem.itemInfo.effectEx * 0.01 * param7;
            }
            if (param8 > 0)
            {
                _loc_15 = VipConfig.instance.getVipConfigByType(param9);
                if (_loc_15)
                {
                    _loc_12 = _loc_12 + _loc_10[param1] * int(_loc_15.desc) * int(_loc_15["vip" + param8]) * 0.01;
                }
            }
            return int(_loc_12);
        }// end function

        public static function getMountCombat(param1:int, param2:int, param3:Array, param4:Array, param5:int, param6:int, param7:int, param8:int) : int
        {
            var _loc_13:ItemData = null;
            var _loc_14:String = null;
            var _loc_15:Array = null;
            var _loc_16:Dictionary = null;
            var _loc_17:TSkill = null;
            var _loc_18:SkillInfo = null;
            var _loc_19:int = 0;
            var _loc_20:Number = NaN;
            var _loc_21:SPlayerItem = null;
            var _loc_22:TVip = null;
            var _loc_9:* = MountConfig.instance.attribute;
            var _loc_10:* = MountConfig.instance.getMountInfoByCode(param1, param2);
            var _loc_11:* = PlayerTargetConfig.instance.getInfoById(_mountGroupItem.itemInfo.effectEx);
            var _loc_12:Number = 0;
            for each (_loc_14 in _loc_9)
            {
                
                _loc_20 = 0;
                _loc_20 = _loc_20 + _loc_10[_loc_14];
                for each (_loc_21 in param4)
                {
                    
                    _loc_13 = new ItemData(_loc_21);
                    if (_loc_13 && !ItemsUtil.isPrescriOutTime(_loc_13))
                    {
                        _loc_20 = _loc_20 + _loc_13.itemInfo[_loc_14];
                    }
                }
                if (param5 > 0 && _loc_11.hasOwnProperty(_loc_14))
                {
                    _loc_20 = _loc_20 + _loc_11[_loc_14] * param5;
                }
                if (param6 > 0)
                {
                    _loc_20 = _loc_20 + _loc_10[_loc_14] * _mountQualifiedItem.itemInfo.effectEx * 0.01 * param6;
                }
                if (param7 > 0)
                {
                    _loc_22 = VipConfig.instance.getVipConfigByType(param8);
                    if (_loc_22)
                    {
                        _loc_20 = _loc_20 + _loc_10[_loc_14] * int(_loc_22.desc) * int(_loc_22["vip" + param7]) * 0.01;
                    }
                }
                _loc_20 = CombatUtil.getCombatValueByName(_loc_14, int(_loc_20));
                _loc_12 = _loc_12 + _loc_20;
            }
            _loc_15 = param3;
            _loc_16 = new Dictionary();
            _loc_19 = 0;
            while (_loc_19 < _loc_15.length)
            {
                
                _loc_17 = SkillConfig.instance.getInfoById(_loc_15[_loc_19]);
                _loc_18 = _loc_16[_loc_17.posType] as SkillInfo;
                if (_loc_18 == null || _loc_18 && _loc_17.skillLevel > _loc_18.tSkill.skillLevel)
                {
                    _loc_16[_loc_17.posType] = _loc_17;
                }
                _loc_19++;
            }
            for each (_loc_17 in _loc_16)
            {
                
                _loc_12 = _loc_12 + _loc_17.combat;
            }
            return int(_loc_12);
        }// end function

        private static function getHeightestSkillByType(param1:int, param2:int) : SkillInfo
        {
            var _loc_3:Array = null;
            var _loc_4:SkillInfo = null;
            var _loc_5:SkillInfo = null;
            var _loc_7:SPublicPet2 = null;
            var _loc_8:int = 0;
            if (param1 == ESkillCategory._EPetSkill)
            {
                _loc_7 = Cache.instance.newPet.pet;
                _loc_8 = 0;
                _loc_3 = [];
                _loc_8 = 0;
                while (_loc_8 < 8)
                {
                    
                    if (_loc_7.code >= (_loc_8 + 1))
                    {
                        _loc_4 = Cache.instance.newPet.getPetSkill(_loc_8 + PetConst.PASSIVE_SKILL_START_POS);
                        if (_loc_4)
                        {
                            _loc_3.push(_loc_4);
                        }
                    }
                    _loc_8++;
                }
            }
            else
            {
                _loc_3 = SkillUtil.getLearnedSkillByType(param1);
            }
            var _loc_6:int = 0;
            while (_loc_6 < _loc_3.length)
            {
                
                _loc_4 = _loc_3[_loc_6];
                if (_loc_4.tSkill.posType == param2)
                {
                    if (_loc_5 == null || _loc_4.tSkill.skillLevel > _loc_5.tSkill.skillLevel)
                    {
                        _loc_5 = _loc_4;
                    }
                }
                _loc_6++;
            }
            return _loc_5;
        }// end function

        public static function getSkillBookStateByItem(param1:ItemData) : int
        {
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:Array = null;
            var _loc_9:int = 0;
            var _loc_10:TSkill = null;
            var _loc_11:SkillInfo = null;
            var _loc_12:TMountConfig = null;
            var _loc_13:FashionAdvanceData = null;
            var _loc_2:int = 0;
            var _loc_3:* = param1.itemInfo.effect;
            var _loc_4:* = SkillConfig.instance.getInfoById(_loc_3);
            if (_loc_4)
            {
                _loc_5 = ItemsUtil.getSkillTypeByItemData(param1);
                _loc_6 = FashionUtil.getFashionTypeBySkillType(_loc_5);
                if (_loc_5 == ESkillCategory._EMountSkill)
                {
                    _loc_7 = Cache.instance.mount.mountData.mountLevel;
                }
                else if (_loc_5 == ESkillCategory._EPetSkill)
                {
                    _loc_7 = Cache.instance.newPet.pet ? (Cache.instance.newPet.pet.code) : (0);
                }
                else if (FashionUtil.isFashionSkill(_loc_5))
                {
                    _loc_13 = Cache.instance.fashion.getFashionInfo(_loc_6);
                    _loc_7 = _loc_13 ? (_loc_13.advanceInfo.code) : (0);
                }
                _loc_8 = MountConfig.instance.getFashionsByType(_loc_6);
                _loc_9 = _loc_4.posType;
                for each (_loc_12 in _loc_8)
                {
                    
                    if (_loc_12.skillList)
                    {
                        _loc_10 = SkillConfig.instance.getInfoById(int(_loc_12.skillList));
                        if (_loc_10.posType == _loc_9)
                        {
                            if (_loc_7 >= _loc_12.code)
                            {
                                _loc_11 = getHeightestSkillByType(_loc_5, _loc_9);
                                if (_loc_11 == null)
                                {
                                    if (_loc_4.skillLevel == 1)
                                    {
                                        _loc_2 = 1;
                                    }
                                    else
                                    {
                                        _loc_2 = 0;
                                    }
                                }
                                else if (_loc_11.tSkill.skillLevel >= _loc_4.skillLevel)
                                {
                                    _loc_2 = -1;
                                }
                                else if (_loc_4.skillLevel - _loc_11.tSkill.skillLevel == 1)
                                {
                                    _loc_2 = 2;
                                }
                                else
                                {
                                    _loc_2 = 0;
                                }
                            }
                            else
                            {
                                _loc_2 = 0;
                            }
                            break;
                        }
                    }
                }
            }
            return _loc_2;
        }// end function

        public static function isSkillBookAvailable(param1:ItemData) : Boolean
        {
            var _loc_2:Boolean = false;
            var _loc_8:TSkill = null;
            var _loc_9:TMountConfig = null;
            var _loc_3:* = param1.itemInfo.effect;
            var _loc_4:* = Cache.instance.mount.mountData.mountLevel;
            var _loc_5:* = SkillConfig.instance.getInfoById(_loc_3);
            var _loc_6:* = _loc_5.posType;
            var _loc_7:* = MountConfig.instance.mountMap;
            for each (_loc_9 in _loc_7)
            {
                
                if (_loc_9.skillList)
                {
                    _loc_8 = SkillConfig.instance.getInfoById(int(_loc_9.skillList));
                    if (_loc_8.posType == _loc_6)
                    {
                        if (_loc_4 >= _loc_9.code)
                        {
                            _loc_2 = true;
                        }
                        else
                        {
                            _loc_2 = false;
                            MsgManager.showRollTipsMsg(Language.getStringByParam(20698, _loc_9.code), MsgRollTipsType.msgRollTips3);
                        }
                        break;
                    }
                }
            }
            return _loc_2;
        }// end function

        public static function isHasBlessItem(param1:int) : ItemData
        {
            var _loc_2:ItemData = null;
            var _loc_5:ItemData = null;
            var _loc_6:int = 0;
            var _loc_3:* = Cache.instance.pack.backPackCache.getItemsByGroupCategoryAndType(EGroup._EGroupStuff, EStuff._EStuffAdvance, param1);
            var _loc_4:* = _loc_3.length;
            while (_loc_6 < _loc_4)
            {
                
                _loc_2 = _loc_3[_loc_6] as ItemData;
                if (_loc_2.itemInfo.effectEx == 1)
                {
                    if (ItemsUtil.isPrescriOutTime(_loc_2))
                    {
                        ;
                    }
                    else
                    {
                        _loc_5 = _loc_2;
                        break;
                    }
                }
                _loc_6++;
            }
            return _loc_5;
        }// end function

        public static function getSystemObjByItem(param1:ItemData) : Object
        {
            var _loc_3:int = 0;
            var _loc_4:FashionAdvanceData = null;
            var _loc_2:* = new Object();
            if (ItemsUtil.isMountAdvanced(param1))
            {
                _loc_2.name = Language.getString(35344);
                _loc_2.level = Cache.instance.mount.mountData ? (Cache.instance.mount.mountData.mountLevel) : (1);
            }
            else if (ItemsUtil.isPetAdvanced(param1))
            {
                _loc_2.name = Language.getString(35345);
                _loc_2.level = Cache.instance.newPet.pet ? (Cache.instance.newPet.pet.code) : (1);
            }
            else if (ItemsUtil.isFashionAdvanceProp(param1))
            {
                _loc_3 = FashionUtil.getFashionTypeByAdvanceType(param1.itemInfo.type);
                _loc_4 = Cache.instance.fashion.getFashionInfo(_loc_3);
                _loc_2.name = FashionUtil.getFashionNameByType(_loc_3);
                _loc_2.level = _loc_4 && _loc_4.advanceInfo ? (_loc_4.advanceInfo.code) : (0);
            }
            return _loc_2;
        }// end function

    }
}
